Integrated circuits (ICs) can be implemented to perform a variety of functions. Some ICs can be programmed to perform specified functions. One example of an IC that can be programmed is a field programmable gate array (FPGA). An FPGA typically includes an array of programmable tiles. These programmable tiles may include, for example, input/output blocks (IOBs), configurable logic blocks (CLBs), dedicated random access memory blocks (BRAM), multipliers, digital signal processing blocks (DSPs), processors, clock managers, delay lock loops (DLLs), and so forth.
Each programmable tile typically includes both programmable interconnect circuitry and programmable logic circuitry. The programmable interconnect circuitry typically includes a large number of interconnect lines of varying lengths interconnected by programmable interconnect points (PIPs). The programmable logic circuitry implements the logic of a user design using programmable elements that may include, for example, function generators, registers, arithmetic logic, and so forth.
The programmable interconnect and programmable logic circuitries are typically programmed by loading a stream of configuration data into internal configuration memory cells that define how the programmable elements are configured. The configuration data can be read from memory (e.g., from an external programmable read-only memory or “PROM”) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
Another type of programmable IC is the complex programmable logic device, or CPLD. A CPLD includes two or more “function blocks” connected together and to input/output (I/O) resources by an interconnect switch matrix. Each function block of the CPLD includes a two-level AND/OR structure similar to those used in programmable logic arrays (PLAs) and programmable array logic (PAL) devices. In CPLDs, configuration data is typically stored on-chip in non-volatile memory. In some CPLDs, configuration data is stored on-chip in non-volatile memory, then downloaded to volatile memory as part of an initial configuration (programming) sequence.
For all of these programmable ICs, the functionality of the device is controlled by data bits provided to the device for that purpose. The data bits may be stored in volatile memory (e.g., static memory cells, as in FPGAs and some CPLDs), in non-volatile memory (e.g., FLASH memory, as in some CPLDs), or in any other type of memory cell.
Other programmable ICs are programmed by applying a processing layer, such as a metal layer, that programmably interconnects the various elements on the device. These programmable ICs are known as mask programmable devices. Programmable ICs may also be implemented in other ways, e.g., using fuse or antifuse technology. The phrase “programmable IC” may include, but is not limited to, these devices and further may encompass devices that are only partially programmable. For example, one type of programmable IC includes a combination of hard-coded transistor logic and a programmable switch fabric that programmably interconnects the hard-coded transistor logic.
Other varieties of programmable ICs may include programmable circuitry in which a circuit design may be implemented responsive to loading a stream of configuration data in combination with one or more other circuits and/or systems. An application specific integrated circuit (ASIC), for example, may include programmable circuitry. In another example, a system-on-chip (SOC) may include programmable circuitry.
An SOC is an IC that includes a plurality of different subsystems. The subsystems are included within a single chip substrate. The subsystems of the SOC are integrated to work cooperatively with one another. One example of an SOC is a chip level implementation of a computer or other data processing system. For example, the SOC may include a processor that executes program code such as an operating system and/or one or more applications. The processor operates cooperatively with one or more of the other on-chip subsystems. The other subsystems may be digital circuits, analog circuits, mixed-signal circuits, or the like. Exemplary subsystems that may be included within an SOC and operate cooperatively with a processor may include, but are not limited to, wireless transceivers, signal processors, CODECs, memory, memory controllers, I/O peripherals, and the like. One or more of the subsystems may be implemented in the SOC within programmable circuitry.
As may be observed from the foregoing discussion, programmable ICs may be highly complex. The capacity of modern programmable ICs is often so large that the circuit design implemented within the programmable IC is the result of work from a team of circuit designers as opposed to a single individual working alone. Once the programmable IC is released into the field with a circuit design implemented therein, the ability of one to learn about the particular elements of the circuit design within the programmable IC is significantly limited or non-existent.
If, for example, the programmable IC requires troubleshooting or other maintenance, the individual, or individuals, performing the troubleshooting are unlikely to be the original circuit designers. Much of the design information available within an electronic design automation tool used by the original circuit designers, for example, is not available to the persons conducting the troubleshooting. In consequence, the personnel conducting troubleshooting may not know, and have no way of ascertaining, the implementation details of the circuit design within the programmable IC. The implementation details, however, may be necessary for troubleshooting the programmable IC or troubleshooting the larger system in which the programmable IC is included.
In other cases, even if the original circuit designers are available for troubleshooting, the ability to re-configure the programmable IC means that there is no guarantee that the circuit design implemented within the programmable IC at the time that troubleshooting is performed is the same as the original circuit design.